#!/bin/bash

# JDK安装脚本
# 功能：自动检测Linux发行版并安装JDK
# 版本：1.0
# 作者：JDK安装脚本生成器

# 设置脚本严格模式
set -euo pipefail

# 全局变量定义
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
LOG_DIR="${SCRIPT_DIR}/logs"
TEMP_DIR="${SCRIPT_DIR}/temp"
CONFIG_DIR="${SCRIPT_DIR}/config"

# JDK安装配置
JDK_VERSION="21"
JDK_VENDOR="Amazon Corretto"
JDK_INSTALL_DIR="$HOME/java"
JDK_TEMP_DIR="${TEMP_DIR}/jdk"
JDK_EXTRACTED_DIR=""  # 将在运行时动态检测
JAVA_HOME=""  # 将在运行时动态设置

# 下载配置
JDK_DOWNLOAD_URL="https://d10.injdk.cn/openjdk/amazon/21/amazon-corretto-21-x64-linux-jdk.tar.gz"
JDK_FILENAME="amazon-corretto-21-x64-linux-jdk.tar.gz"
JDK_CHECKSUM=""

# 安装选项
INTERACTIVE_MODE=true
SILENT_MODE=false
FORCE_INSTALL=false

# 日志级别
LOG_LEVEL_DEBUG=0
LOG_LEVEL_INFO=1
LOG_LEVEL_WARN=2
LOG_LEVEL_ERROR=3
LOG_LEVEL_FATAL=4
CURRENT_LOG_LEVEL=$LOG_LEVEL_INFO

# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color

# 错误码定义
ERROR_SUCCESS=0
ERROR_GENERAL=1
ERROR_SYSTEM_REQUIREMENTS=1001
ERROR_PERMISSION_DENIED=1002
ERROR_DISK_SPACE=1003
ERROR_NETWORK=1004
ERROR_DEPENDENCY_MISSING=1005
ERROR_DOWNLOAD_FAILED=2001
ERROR_DOWNLOAD_TIMEOUT=2002
ERROR_CHECKSUM_MISMATCH=2003
ERROR_URL_INVALID=2004
ERROR_FILE_CORRUPTED=2005
ERROR_EXTRACT_FAILED=3001
ERROR_INSTALL_FAILED=3002
ERROR_CONFIG_FAILED=3003
ERROR_VERIFICATION_FAILED=3004
ERROR_ROLLBACK_FAILED=3005

# =============================================================================
# 工具函数
# =============================================================================

# 显示帮助信息
show_help() {
    cat << EOF
JDK安装脚本

用法: $0 [选项]

选项:
    -h, --help          显示此帮助信息
    -v, --version       显示JDK版本
    -s, --silent        静默安装模式
    -f, --force         强制安装，覆盖现有安装
    -d, --dir DIR       指定安装目录 (默认: $HOME/java)
    --version VER       指定JDK版本 (默认: 21)
    --url URL           指定下载URL
    --debug             启用调试模式

示例:
    $0                  交互式安装
    $0 -s               静默安装
    $0 -f               强制安装
    $0 -d /opt/java     安装到指定目录

EOF
}

# 显示版本信息
show_version() {
    echo "JDK安装脚本 v1.0"
    echo "目标JDK版本: Amazon Corretto ${JDK_VERSION}"
}

# 日志记录函数
log_message() {
    local level="$1"
    local message="$2"
    local module="${3:-MAIN}"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local pid=$$
    
    # 检查日志级别
    case $level in
        "DEBUG") [[ $CURRENT_LOG_LEVEL -gt $LOG_LEVEL_DEBUG ]] && return ;;
        "INFO")  [[ $CURRENT_LOG_LEVEL -gt $LOG_LEVEL_INFO ]] && return ;;
        "WARN")  [[ $CURRENT_LOG_LEVEL -gt $LOG_LEVEL_WARN ]] && return ;;
        "ERROR") [[ $CURRENT_LOG_LEVEL -gt $LOG_LEVEL_ERROR ]] && return ;;
        "FATAL") [[ $CURRENT_LOG_LEVEL -gt $LOG_LEVEL_FATAL ]] && return ;;
    esac
    
    # 格式化日志消息
    local log_entry="[${timestamp}] [${level}] [${module}] [${pid}] ${message}"
    
    # 写入日志文件
    if [[ -d "$LOG_DIR" ]]; then
        echo "$log_entry" >> "${LOG_DIR}/install_$(date +%Y%m%d_%H%M%S).log"
    fi
    
    # 控制台输出
    if [[ "$SILENT_MODE" != true ]]; then
        case $level in
            "DEBUG") echo -e "${BLUE}${log_entry}${NC}" ;;
            "INFO")  echo -e "${GREEN}${log_entry}${NC}" ;;
            "WARN")  echo -e "${YELLOW}${log_entry}${NC}" ;;
            "ERROR") echo -e "${RED}${log_entry}${NC}" ;;
            "FATAL") echo -e "${RED}${log_entry}${NC}" ;;
            *)       echo "$log_entry" ;;
        esac
    fi
}

# 便捷日志函数
log_debug() { log_message "DEBUG" "$1" "${2:-MAIN}"; }
log_info() { log_message "INFO" "$1" "${2:-MAIN}"; }
log_warn() { log_message "WARN" "$1" "${2:-MAIN}"; }
log_error() { log_message "ERROR" "$1" "${2:-MAIN}"; }
log_fatal() { log_message "FATAL" "$1" "${2:-MAIN}"; }

# 显示状态信息
show_status() {
    local status="$1"
    local message="$2"
    
    case $status in
        "success")
            echo -e "${GREEN}✓ ${message}${NC}"
            ;;
        "warning")
            echo -e "${YELLOW}⚠ ${message}${NC}"
            ;;
        "error")
            echo -e "${RED}✗ ${message}${NC}"
            ;;
        "info")
            echo -e "${BLUE}ℹ ${message}${NC}"
            ;;
    esac
}

# 显示进度条
show_progress() {
    local current="$1"
    local total="$2"
    local message="$3"
    
    local percent=$((current * 100 / total))
    local bar_length=50
    local filled_length=$((percent * bar_length / 100))
    
    printf "\r[%3d%%] [" $percent
    printf "%*s" $filled_length | tr ' ' '='
    printf "%*s] %s" $((bar_length - filled_length)) "" "$message"
}

# 错误处理函数
handle_error() {
    local error_code="$1"
    local error_message="$2"
    local module="${3:-MAIN}"
    
    log_error "$error_message (错误码: $error_code)" "$module"
    
    case $error_code in
        $ERROR_SYSTEM_REQUIREMENTS)
            log_error "系统要求不满足，请检查系统环境" "$module"
            ;;
        $ERROR_PERMISSION_DENIED)
            log_error "权限不足，请检查文件和目录权限" "$module"
            ;;
        $ERROR_DISK_SPACE)
            log_error "磁盘空间不足，请清理磁盘空间" "$module"
            ;;
        $ERROR_NETWORK)
            log_error "网络连接问题，请检查网络设置" "$module"
            ;;
        $ERROR_DOWNLOAD_FAILED)
            log_error "下载失败，请检查网络连接和下载链接" "$module"
            ;;
        $ERROR_EXTRACT_FAILED)
            log_error "解压失败，请检查文件完整性" "$module"
            ;;
        $ERROR_CONFIG_FAILED)
            log_error "配置失败，请手动配置环境变量" "$module"
            ;;
        *)
            log_error "未知错误，请查看日志获取详细信息" "$module"
            ;;
    esac
    
    exit $error_code
}

# 检测Linux发行版
detect_linux_distribution() {
    log_debug "检测Linux发行版" "SYSTEM_CHECK"
    
    if [[ -f /etc/os-release ]]; then
        . /etc/os-release
        echo "$ID"
    elif [[ -f /etc/redhat-release ]]; then
        echo "centos"
    elif [[ -f /etc/debian_version ]]; then
        echo "debian"
    else
        echo "unknown"
    fi
}

# 检查命令是否存在
command_exists() {
    command -v "$1" >/dev/null 2>&1
}

# 检查磁盘空间
check_disk_space() {
    local required_mb="$1"
    local path="${2:-$HOME}"
    
    log_debug "检查磁盘空间，需要: ${required_mb}MB" "SYSTEM_CHECK"
    
    local available_kb=$(df "$path" | awk 'NR==2 {print $4}')
    local available_mb=$((available_kb / 1024))
    
    if [[ $available_mb -lt $required_mb ]]; then
        log_error "磁盘空间不足: 需要${required_mb}MB，可用${available_mb}MB" "SYSTEM_CHECK"
        return $ERROR_DISK_SPACE
    fi
    
    log_info "磁盘空间检查通过: 可用${available_mb}MB" "SYSTEM_CHECK"
    return 0
}

# 检查网络连接
check_network_connection() {
    log_debug "检查网络连接" "SYSTEM_CHECK"
    
    if command_exists curl; then
        curl -s --connect-timeout 5 https://www.google.com >/dev/null 2>&1
    elif command_exists wget; then
        wget -q --timeout=5 --tries=1 https://www.google.com -O /dev/null
    else
        log_error "缺少curl或wget命令" "SYSTEM_CHECK"
        return $ERROR_DEPENDENCY_MISSING
    fi
    
    if [[ $? -ne 0 ]]; then
        log_error "网络连接失败" "SYSTEM_CHECK"
        return $ERROR_NETWORK
    fi
    
    log_info "网络连接检查通过" "SYSTEM_CHECK"
    return 0
}

# 创建必要的目录
create_directories() {
    log_debug "创建必要的目录" "SYSTEM_INIT"
    
    local dirs=("$LOG_DIR" "$TEMP_DIR" "$JDK_INSTALL_DIR" "$JDK_TEMP_DIR")
    
    for dir in "${dirs[@]}"; do
        if [[ ! -d "$dir" ]]; then
            mkdir -p "$dir" || {
                log_error "无法创建目录: $dir" "SYSTEM_INIT"
                return $ERROR_PERMISSION_DENIED
            }
            log_debug "已创建目录: $dir" "SYSTEM_INIT"
        fi
    done
    
    return 0
}

# =============================================================================
# JDK安装核心函数
# =============================================================================

# 初始化JDK安装环境
jdk_install_init() {
    log_info "初始化JDK安装环境" "JDK_INSTALL"
    
    # 创建必要目录
    create_directories || return $?
    
    # 检查系统环境
    if ! check_disk_space 500 "$HOME"; then
        return $ERROR_DISK_SPACE
    fi
    
    if ! check_network_connection; then
        return $ERROR_NETWORK
    fi
    
    log_info "JDK安装环境初始化完成" "JDK_INSTALL"
    return 0
}

# 动态检测JDK解压后的目录名
detect_jdk_extracted_dir() {
    log_debug "检测JDK解压后的目录名" "JDK_INSTALL"
    
    local download_path="${JDK_TEMP_DIR}/${JDK_FILENAME}"
    
    # 从压缩包中获取根目录名
    local root_dir=$(tar -tzf "$download_path" | head -n 1 | cut -f1 -d"/")
    
    if [[ -n "$root_dir" ]]; then
        JDK_EXTRACTED_DIR="$root_dir"
        JAVA_HOME="${JDK_INSTALL_DIR}/${JDK_EXTRACTED_DIR}"
        log_info "检测到JDK目录: $JDK_EXTRACTED_DIR" "JDK_INSTALL"
        return 0
    else
        log_error "无法检测JDK目录名" "JDK_INSTALL"
        return $ERROR_INSTALL_FAILED
    fi
}

# 检查现有Java安装
jdk_pre_check() {
    log_info "检查现有Java安装" "JDK_INSTALL"
    
    # 检查是否已安装Java
    if command_exists java; then
        local existing_version=$(java -version 2>&1 | head -n 1 | cut -d'"' -f2)
        log_info "检测到现有Java安装: $existing_version" "JDK_INSTALL"
        
        if [[ "$existing_version" == *"21"* ]]; then
            if [[ "$FORCE_INSTALL" != true ]]; then
                if [[ "$INTERACTIVE_MODE" == true ]]; then
                    echo "已检测到JDK 21安装: $existing_version"
                    read -p "是否要覆盖安装? (y/N): " -n 1 -r
                    echo
                    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
                        log_info "用户选择跳过JDK安装" "JDK_INSTALL"
                        return 1
                    fi
                else
                    log_info "已存在JDK 21，跳过安装 (使用--force强制覆盖)" "JDK_INSTALL"
                    return 1
                fi
            fi
        fi
    fi
    
    # 检查系统架构
    local arch=$(uname -m)
    if [[ "$arch" != "x86_64" ]]; then
        log_error "不支持的系统架构: $arch (仅支持x86_64)" "JDK_INSTALL"
        return $ERROR_SYSTEM_REQUIREMENTS
    fi
    
    log_info "JDK预检查通过" "JDK_INSTALL"
    return 0
}

# 下载JDK
jdk_download() {
    log_info "开始下载JDK ${JDK_VERSION}" "JDK_DOWNLOAD"
    
    local download_path="${JDK_TEMP_DIR}/${JDK_FILENAME}"
    local temp_download_path="${TEMP_DIR}/${JDK_FILENAME}"
    
    # 首先检查temp目录中是否已存在JDK安装包
    if [[ -f "$temp_download_path" ]]; then
        local file_size=$(stat -c%s "$temp_download_path" 2>/dev/null || stat -f%z "$temp_download_path" 2>/dev/null)
        if [[ $file_size -gt 100000000 ]]; then  # 大于100MB认为是有效文件
            log_info "发现本地JDK安装包，跳过下载: $temp_download_path" "JDK_DOWNLOAD"
            # 复制到临时目录
            cp "$temp_download_path" "$download_path" || {
                log_error "复制本地安装包失败" "JDK_DOWNLOAD"
                return $ERROR_DOWNLOAD_FAILED
            }
            log_info "使用本地JDK安装包: ${file_size}字节" "JDK_DOWNLOAD"
            return 0
        else
            log_warn "本地JDK安装包大小异常，将重新下载: ${file_size}字节" "JDK_DOWNLOAD"
        fi
    fi
    
    # 检查JDK临时目录中是否已存在文件
    if [[ -f "$download_path" ]]; then
        if [[ "$FORCE_INSTALL" != true ]]; then
            log_info "JDK安装包已存在，跳过下载" "JDK_DOWNLOAD"
            return 0
        else
            rm -f "$download_path"
        fi
    fi
    
    # 设置超时时间（3分钟=180秒）
    local timeout_seconds=180
    
    # 使用curl或wget下载，添加超时设置
    if command_exists curl; then
        log_info "使用curl下载JDK (超时: ${timeout_seconds}秒)" "JDK_DOWNLOAD"
        curl -L -o "$download_path" "$JDK_DOWNLOAD_URL" --progress-bar --max-time $timeout_seconds --connect-timeout 30 || {
            log_error "curl下载失败或超时" "JDK_DOWNLOAD"
            return $ERROR_DOWNLOAD_TIMEOUT
        }
    elif command_exists wget; then
        log_info "使用wget下载JDK (超时: ${timeout_seconds}秒)" "JDK_DOWNLOAD"
        wget -O "$download_path" "$JDK_DOWNLOAD_URL" --progress=bar:force --timeout=$timeout_seconds --tries=3 || {
            log_error "wget下载失败或超时" "JDK_DOWNLOAD"
            return $ERROR_DOWNLOAD_TIMEOUT
        }
    else
        log_error "缺少curl或wget命令" "JDK_DOWNLOAD"
        return $ERROR_DEPENDENCY_MISSING
    fi
    
    # 检查下载文件
    if [[ ! -f "$download_path" ]]; then
        log_error "下载文件不存在" "JDK_DOWNLOAD"
        return $ERROR_DOWNLOAD_FAILED
    fi
    
    local file_size=$(stat -c%s "$download_path" 2>/dev/null || stat -f%z "$download_path" 2>/dev/null)
    if [[ $file_size -lt 100000000 ]]; then  # 小于100MB可能是错误文件
        log_error "下载文件大小异常: ${file_size}字节" "JDK_DOWNLOAD"
        return $ERROR_FILE_CORRUPTED
    fi
    
    # 保留安装包到temp目录
    cp "$download_path" "$temp_download_path" || {
        log_warn "无法保存安装包到temp目录" "JDK_DOWNLOAD"
    }
    
    log_info "JDK下载完成: ${file_size}字节" "JDK_DOWNLOAD"
    return 0
}

# 验证下载文件
jdk_verify() {
    log_info "验证下载文件完整性" "JDK_INSTALL"
    
    local download_path="${JDK_TEMP_DIR}/${JDK_FILENAME}"
    
    if [[ ! -f "$download_path" ]]; then
        log_error "下载文件不存在" "JDK_INSTALL"
        return $ERROR_FILE_CORRUPTED
    fi
    
    # 检查文件类型 - 使用更通用的方法
    if ! tar -tzf "$download_path" >/dev/null 2>&1; then
        log_error "文件类型不正确，应为gzip压缩文件" "JDK_INSTALL"
        return $ERROR_FILE_CORRUPTED
    fi
    
    # 如果提供了校验和，则验证校验和
    if [[ -n "$JDK_CHECKSUM" ]]; then
        log_debug "验证文件校验和" "JDK_INSTALL"
        local actual_checksum=$(sha256sum "$download_path" | cut -d' ' -f1)
        if [[ "$actual_checksum" != "$JDK_CHECKSUM" ]]; then
            log_error "文件校验和不匹配" "JDK_INSTALL"
            return $ERROR_CHECKSUM_MISMATCH
        fi
    fi
    
    log_info "文件验证通过" "JDK_INSTALL"
    return 0
}

# 安装JDK
jdk_install() {
    log_info "开始安装JDK" "JDK_INSTALL"
    
    local download_path="${JDK_TEMP_DIR}/${JDK_FILENAME}"
    
    # 动态检测解压后的目录名
    detect_jdk_extracted_dir || return $?
    
    local install_path="${JDK_INSTALL_DIR}/${JDK_EXTRACTED_DIR}"
    
    # 如果已存在安装目录且强制安装，则先删除
    if [[ -d "$install_path" && "$FORCE_INSTALL" == true ]]; then
        log_info "删除现有JDK安装目录" "JDK_INSTALL"
        rm -rf "$install_path"
    fi
    
    # 检查是否已安装
    if [[ -d "$install_path" ]]; then
        log_info "JDK已安装，跳过安装步骤" "JDK_INSTALL"
        return 0
    fi
    
    # 解压安装包
    log_info "解压JDK安装包" "JDK_INSTALL"
    if ! tar -xzf "$download_path" -C "$JDK_INSTALL_DIR"; then
        log_error "解压失败" "JDK_INSTALL"
        return $ERROR_EXTRACT_FAILED
    fi
    
    # 检查解压结果
    if [[ ! -d "$install_path" ]]; then
        log_error "解压后目录不存在" "JDK_INSTALL"
        return $ERROR_INSTALL_FAILED
    fi
    
    # 设置权限
    log_info "设置JDK目录权限" "JDK_INSTALL"
    chmod -R 755 "$install_path" || {
        log_error "设置权限失败" "JDK_INSTALL"
        return $ERROR_PERMISSION_DENIED
    }
    
    # 创建符号链接
    local jdk_link="${JDK_INSTALL_DIR}/jdk21"
    if [[ -L "$jdk_link" ]]; then
        rm "$jdk_link"
    fi
    ln -s "$JDK_EXTRACTED_DIR" "$jdk_link" || {
        log_warn "创建符号链接失败" "JDK_INSTALL"
    }
    
    log_info "JDK安装完成" "JDK_INSTALL"
    return 0
}

# 配置环境变量
jdk_configure() {
    log_info "配置JDK环境变量" "JDK_CONFIG"
    
    # 检测Shell类型
    local shell_type=$(basename "$SHELL")
    local config_file=""
    
    case $shell_type in
        bash)
            if [[ -f "$HOME/.bashrc" ]]; then
                config_file="$HOME/.bashrc"
            elif [[ -f "$HOME/.bash_profile" ]]; then
                config_file="$HOME/.bash_profile"
            else
                config_file="$HOME/.bashrc"
                touch "$config_file"
            fi
            ;;
        zsh)
            config_file="$HOME/.zshrc"
            [[ ! -f "$config_file" ]] && touch "$config_file"
            ;;
        *)
            config_file="$HOME/.profile"
            [[ ! -f "$config_file" ]] && touch "$config_file"
            ;;
    esac
    
    log_info "使用配置文件: $config_file" "JDK_CONFIG"
    
    # 备份配置文件
    local backup_file="${config_file}.backup.$(date +%Y%m%d_%H%M%S)"
    cp "$config_file" "$backup_file" || {
        log_warn "无法备份配置文件" "JDK_CONFIG"
    }
    
    # 检查是否已存在配置
    if grep -q "# JDK Environment Configuration by Install Script" "$config_file" 2>/dev/null; then
        if [[ "$FORCE_INSTALL" == true ]]; then
            # 删除现有配置
            log_info "删除现有JDK配置" "JDK_CONFIG"
            sed -i '/# JDK Environment Configuration by Install Script/,/# End of JDK Configuration/d' "$config_file"
        else
            log_info "JDK环境变量已配置，跳过配置步骤" "JDK_CONFIG"
            return 0
        fi
    fi
    
    # 添加配置
    cat >> "$config_file" << EOF

# ============================================================================
# JDK Environment Configuration by Install Script
# Installed on: $(date)
# JDK: Amazon Corretto ${JDK_VERSION}
# ============================================================================

# Java Environment
if [ -d "$JAVA_HOME" ]; then
    export JAVA_HOME="$JAVA_HOME"
    export PATH="\$JAVA_HOME/bin:\$PATH"
    export JDK_HOME="\$JAVA_HOME"
fi

# ============================================================================
# End of JDK Configuration
# ============================================================================
EOF
    
    if [[ $? -ne 0 ]]; then
        log_error "写入配置文件失败" "JDK_CONFIG"
        return $ERROR_CONFIG_FAILED
    fi
    
    log_info "JDK环境变量配置完成" "JDK_CONFIG"
    return 0
}

# 验证JDK安装
jdk_verify_installation() {
    log_info "验证JDK安装" "JDK_VERIFY"
    
    # 设置临时环境变量用于验证
    export JAVA_HOME="$JAVA_HOME"
    export PATH="$JAVA_HOME/bin:$PATH"
    
    # 检查Java命令
    if ! command_exists java; then
        log_error "java命令不可用" "JDK_VERIFY"
        return $ERROR_VERIFICATION_FAILED
    fi
    
    # 检查Java版本
    local java_version=$(java -version 2>&1 | head -n 1)
    if [[ ! "$java_version" == *"21"* ]]; then
        log_error "Java版本不正确: $java_version" "JDK_VERIFY"
        return $ERROR_VERIFICATION_FAILED
    fi
    
    # 检查javac命令
    if ! command_exists javac; then
        log_error "javac命令不可用" "JDK_VERIFY"
        return $ERROR_VERIFICATION_FAILED
    fi
    
    log_info "JDK安装验证成功" "JDK_VERIFY"
    log_info "Java版本: $java_version" "JDK_VERIFY"
    
    return 0
}

# 清理临时文件
jdk_cleanup() {
    log_info "清理临时文件" "JDK_INSTALL"
    
    if [[ -d "$JDK_TEMP_DIR" ]]; then
        rm -rf "$JDK_TEMP_DIR" || {
            log_warn "清理临时目录失败" "JDK_INSTALL"
        }
    fi
    
    # 注意：不删除TEMP_DIR中的安装包，以便下次使用
    log_info "临时文件清理完成 (保留temp目录中的安装包)" "JDK_INSTALL"
    return 0
}

# =============================================================================
# 主函数
# =============================================================================

# 解析命令行参数
parse_arguments() {
    while [[ $# -gt 0 ]]; do
        case $1 in
            -h|--help)
                show_help
                exit 0
                ;;
            -v|--version)
                show_version
                exit 0
                ;;
            -s|--silent)
                SILENT_MODE=true
                INTERACTIVE_MODE=false
                shift
                ;;
            -f|--force)
                FORCE_INSTALL=true
                shift
                ;;
            -d|--dir)
                JDK_INSTALL_DIR="$2"
                # JAVA_HOME将在detect_jdk_extracted_dir函数中动态设置
                shift 2
                ;;
            --version)
                JDK_VERSION="$2"
                shift 2
                ;;
            --url)
                JDK_DOWNLOAD_URL="$2"
                shift 2
                ;;
            --debug)
                CURRENT_LOG_LEVEL=$LOG_LEVEL_DEBUG
                shift
                ;;
            *)
                log_error "未知参数: $1"
                show_help
                exit 1
                ;;
        esac
    done
}

# 主安装流程
main() {
    log_info "开始JDK安装过程" "MAIN"
    
    # 解析命令行参数
    parse_arguments "$@"
    
    # 初始化安装环境
    jdk_install_init || handle_error $? "JDK安装环境初始化失败"
    
    # 预检查
    if ! jdk_pre_check; then
        if [[ $? -eq 1 ]]; then
            log_info "跳过JDK安装" "MAIN"
            exit 0
        else
            handle_error $? "JDK预检查失败"
        fi
    fi
    
    # 下载JDK
    jdk_download || handle_error $? "JDK下载失败"
    
    # 验证下载文件
    jdk_verify || handle_error $? "JDK文件验证失败"
    
    # 安装JDK
    jdk_install || handle_error $? "JDK安装失败"
    
    # 配置环境变量
    jdk_configure || handle_error $? "JDK环境变量配置失败"
    
    # 验证安装
    jdk_verify_installation || handle_error $? "JDK安装验证失败"
    
    # 清理临时文件
    jdk_cleanup || log_warn "临时文件清理失败"
    
    log_info "JDK安装完成!" "MAIN"
    show_status "success" "JDK ${JDK_VERSION} 安装成功"
    
    if [[ "$INTERACTIVE_MODE" == true && "$SILENT_MODE" != true ]]; then
        # 获取配置文件路径
        local shell_type=$(basename "$SHELL")
        local config_file=""
        
        case $shell_type in
            bash)
                if [[ -f "$HOME/.bashrc" ]]; then
                    config_file="$HOME/.bashrc"
                elif [[ -f "$HOME/.bash_profile" ]]; then
                    config_file="$HOME/.bash_profile"
                else
                    config_file="$HOME/.bashrc"
                fi
                ;;
            zsh)
                config_file="$HOME/.zshrc"
                ;;
            *)
                config_file="$HOME/.profile"
                ;;
        esac
        
        echo
        echo "安装信息:"
        echo "  JDK版本: Amazon Corretto ${JDK_VERSION}"
        echo "  安装路径: $JAVA_HOME"
        echo "  配置文件: $config_file"
        echo
        echo "请运行以下命令使环境变量生效:"
        echo "  source $config_file"
        echo
        echo "验证安装:"
        echo "  java -version"
        echo "  javac -version"
    fi
    
    exit 0
}

# 脚本入口点
if [[ "${BASH_SOURCE[0]}" == "${0}" ]]; then
    main "$@"
fi